Large integers are integers that are, typically, larger than 64 bits in width. Although large integers may include integers of 128 bits and 256 bits in length, large integers are commonly as wide as 4096 or 8192 bits. It will be appreciated that most common processors are designed to operate on 32-bit or 64-bit operands. In other words, a data pipeline in an arithmetic logic unit (ALU) is coupled to a number of registers (e.g., 8) which store operands for an operation. The ALU may be configured to process the operands according to an operation code (opcode) that indicates the type of operation to perform (i.e., addition, subtraction, etc.). The ALU produces a result from the operation and stores the result in another register. However, all operands and results must conform to the same format (e.g., 64-bit integers) and, therefore, large integers cannot be used as operands within the ALU.
Operations on large integers may be performed in software by breaking the large integer up into smaller units corresponding to the format of an ALU. For example, software may add the least significant bits of the large integer operands into the registers of the ALU and use these operands to produce an intermediate result. Then, the next least significant bits of the large integer operands are loaded into the registers of the ALU to produce another intermediate result, and so forth. In some operations, carryover bits may be included in the subsequent operations to produce the next intermediate results. The number of registers addressable by the ALU is typically small (e.g., 8 or 16 registers) and, therefore, storing intermediate results in the available registers may be impossible because all of the available registers quickly become full. To solve this issue, the intermediate results may be transferred from the registers to a memory coupled to the ALU for temporary storage. However, transferring the intermediate results to a memory is a high latency operation that slows down the processing of large integer operations. Thus, there is a need for processing large integer operations that addresses this issue and/or other issues associated with the prior art.